/*
 * jQuery treetable Plugin 3.2.0
 * http://ludo.cubicphuse.nl/jquery-treetable
 *
 * Copyright 2013, Ludo van den Boom
 * Dual licensed under the MIT or GPL Version 2 licenses.
 */
(function($) {
	var Node, Tree, methods;

	Node = (function() {
		function Node(row, tree, settings) {
			var parentId;

			this.row = row;
			this.tree = tree;
			this.settings = settings;

			// TODO Ensure id/parentId is always a string (not int)
			this.id = this.row.data(this.settings.nodeIdAttr);

			// TODO Move this to a setParentId function?
			parentId = this.row.data(this.settings.parentIdAttr);
			if (parentId != null && parentId !== "") {
				this.parentId = parentId;
			}

			this.treeCell = $(this.row.children(this.settings.columnElType)[this.settings.column]);
			this.expander = $(this.settings.expanderTemplate);
			this.indenter = $(this.settings.indenterTemplate);
			this.children = [];
			this.initialized = false;
			this.treeCell.prepend(this.indenter);
		}

		Node.prototype.addChild = function(child) {
			return this.children.push(child);
		};

		Node.prototype.ancestors = function() {
			var ancestors, node;
			node = this;
			ancestors = [];
			while (node = node.parentNode()) {
				ancestors.push(node);
			}
			return ancestors;
		};

		Node.prototype.collapse = function() {
			if (this.collapsed()) {
				return this;
			}

			this.row.removeClass("expanded").addClass("collapsed");

			this._hideChildren();
			this.expander.attr("title", this.settings.stringExpand);

			if (this.initialized && this.settings.onNodeCollapse != null) {
				this.settings.onNodeCollapse.apply(this);
			}

			return this;
		};

		Node.prototype.collapsed = function() {
			return this.row.hasClass("collapsed");
		};

		// TODO destroy: remove event handlers, expander, indenter, etc.

		Node.prototype.expand = function() {
			if (this.expanded()) {
				return this;
			}

			this.row.removeClass("collapsed").addClass("expanded");

			if (this.initialized && this.settings.onNodeExpand != null) {
				this.settings.onNodeExpand.apply(this);
			}

			if ($(this.row).is(":visible")) {
				this._showChildren();
			}

			this.expander.attr("title", this.settings.stringCollapse);

			return this;
		};

		Node.prototype.expanded = function() {
			return this.row.hasClass("expanded");
		};

		Node.prototype.hide = function() {
			this._hideChildren();
			this.row.hide();
			return this;
		};

		Node.prototype.isBranchNode = function() {
			if (this.children.length > 0 || this.row.data(this.settings.branchAttr) === true) {
				return true;
			} else {
				return false;
			}
		};

		Node.prototype.updateBranchLeafClass = function() {
			this.row.removeClass('branch');
			this.row.removeClass('leaf');
			this.row.addClass(this.isBranchNode() ? 'branch' : 'leaf');
		};

		Node.prototype.level = function() {
			return this.ancestors().length;
		};

		Node.prototype.parentNode = function() {
			if (this.parentId != null) {
				return this.tree[this.parentId];
			} else {
				return null;
			}
		};

		Node.prototype.removeChild = function(child) {
			var i = $.inArray(child, this.children);
			return this.children.splice(i, 1)
		};

		Node.prototype.render = function() {
			var handler, settings = this.settings, target;

			if (settings.expandable === true && this.isBranchNode()) {
				handler = function(e) {
					$(this).parents("table").treetable("node", $(this).parents("tr").data(settings.nodeIdAttr)).toggle();
					return e.preventDefault();
				};

				this.indenter.html(this.expander);
				target = settings.clickableNodeNames === true ? this.treeCell : this.expander;

				target.off("click.treetable").on("click.treetable", handler);
				target.off("keydown.treetable").on("keydown.treetable", function(e) {
					if (e.keyCode == 13) {
						handler.apply(this, [e]);
					}
				});
			}

			this.indenter[0].style.paddingLeft = "" + (this.level() * settings.indent) + "px";

			return this;
		};

		Node.prototype.reveal = function() {
			if (this.parentId != null) {
				this.parentNode().reveal();
			}
			return this.expand();
		};

		Node.prototype.setParent = function(node) {
			if (this.parentId != null) {
				this.tree[this.parentId].removeChild(this);
			}
			this.parentId = node.id;
			this.row.data(this.settings.parentIdAttr, node.id);
			return node.addChild(this);
		};

		Node.prototype.show = function() {
			if (!this.initialized) {
				this._initialize();
			}
			this.row.show();
			if (this.expanded()) {
				this._showChildren();
			}
			return this;
		};

		Node.prototype.toggle = function() {
			if (this.expanded()) {
				this.collapse();
			} else {
				this.expand();
			}
			return this;
		};

		Node.prototype._hideChildren = function() {
			var child, _i, _len, _ref, _results;
			_ref = this.children;
			_results = [];
			for (_i = 0, _len = _ref.length; _i < _len; _i++) {
				child = _ref[_i];
				_results.push(child.hide());
			}
			return _results;
		};

		Node.prototype._initialize = function() {
			var settings = this.settings;

			this.render();

			if (settings.expandable === true && settings.initialState === "collapsed") {
				this.collapse();
			} else {
				this.expand();
			}

			if (settings.onNodeInitialized != null) {
				settings.onNodeInitialized.apply(this);
			}

			return this.initialized = true;
		};

		Node.prototype._showChildren = function() {
			var child, _i, _len, _ref, _results;
			_ref = this.children;
			_results = [];
			for (_i = 0, _len = _ref.length; _i < _len; _i++) {
				child = _ref[_i];
				_results.push(child.show());
			}
			return _results;
		};

		return Node;
	})();

	Tree = (function() {
		function Tree(table, settings) {
			this.table = table;
			this.settings = settings;
			this.tree = {};

			// Cache the nodes and roots in simple arrays for quick access/iteration
			this.nodes = [];
			this.roots = [];
		}

		Tree.prototype.collapseAll = function() {
			var node, _i, _len, _ref, _results;
			_ref = this.nodes;
			_results = [];
			for (_i = 0, _len = _ref.length; _i < _len; _i++) {
				node = _ref[_i];
				_results.push(node.collapse());
			}
			return _results;
		};

		Tree.prototype.expandAll = function() {
			var node, _i, _len, _ref, _results;
			_ref = this.nodes;
			_results = [];
			for (_i = 0, _len = _ref.length; _i < _len; _i++) {
				node = _ref[_i];
				_results.push(node.expand());
			}
			return _results;
		};

		Tree.prototype.findLastNode = function(node) {
			if (node.children.length > 0) {
				return this.findLastNode(node.children[node.children.length - 1]);
			} else {
				return node;
			}
		};

		Tree.prototype.loadRows = function(rows) {
			var node, row, i;

			if (rows != null) {
				for (i = 0; i < rows.length; i++) {
					row = $(rows[i]);

					if (row.data(this.settings.nodeIdAttr) != null) {
						node = new Node(row, this.tree, this.settings);
						this.nodes.push(node);
						this.tree[node.id] = node;

						if (node.parentId != null && this.tree[node.parentId]) {
							this.tree[node.parentId].addChild(node);
						} else {
							this.roots.push(node);
						}
					}
				}
			}

			for (i = 0; i < this.nodes.length; i++) {
				node = this.nodes[i].updateBranchLeafClass();
			}

			return this;
		};

		Tree.prototype.move = function(node, destination) {
			// Conditions:
			// 1: +node+ should not be inserted as a child of +node+ itself.
			// 2: +destination+ should not be the same as +node+'s current parent (this
			// prevents +node+ from being moved to the same location where it already
			// is).
			// 3: +node+ should not be inserted in a location in a branch if this would
			// result in +node+ being an ancestor of itself.
			var nodeParent = node.parentNode();
			if (node !== destination && destination.id !== node.parentId && $.inArray(node, destination.ancestors()) === -1) {
				node.setParent(destination);
				this._moveRows(node, destination);

				// Re-render parentNode if this is its first child node, and therefore
				// doesn't have the expander yet.
				if (node.parentNode().children.length === 1) {
					node.parentNode().render();
				}
			}

			if (nodeParent) {
				nodeParent.updateBranchLeafClass();
			}
			if (node.parentNode()) {
				node.parentNode().updateBranchLeafClass();
			}
			node.updateBranchLeafClass();
			return this;
		};

		Tree.prototype.removeNode = function(node) {
			// Recursively remove all descendants of +node+
			this.unloadBranch(node);

			// Remove node from DOM (<tr>)
			node.row.remove();

			// Remove node from parent children list
			if (node.parentId != null) {
				node.parentNode().removeChild(node);
			}

			// Clean up Tree object (so Node objects are GC-ed)
			delete this.tree[node.id];
			this.nodes.splice($.inArray(node, this.nodes), 1);

			return this;
		}

		Tree.prototype.render = function() {
			var root, _i, _len, _ref;
			_ref = this.roots;
			for (_i = 0, _len = _ref.length; _i < _len; _i++) {
				root = _ref[_i];

				// Naming is confusing (show/render). I do not call render on node from
				// here.
				root.show();
			}
			return this;
		};

		Tree.prototype.sortBranch = function(node, sortFun) {
			// First sort internal array of children
			node.children.sort(sortFun);

			// Next render rows in correct order on page
			this._sortChildRows(node);

			return this;
		};

		Tree.prototype.unloadBranch = function(node) {
			// Use a copy of the children array to not have other functions interfere
			// with this function if they manipulate the children array
			// (eg removeNode).
			var children = node.children.slice(0), i;

			for (i = 0; i < children.length; i++) {
				this.removeNode(children[i]);
			}

			// Reset node's collection of children
			node.children = [];

			node.updateBranchLeafClass();

			return this;
		};

		Tree.prototype._moveRows = function(node, destination) {
			var children = node.children, i;

			node.row.insertAfter(destination.row);
			node.render();

			// Loop backwards through children to have them end up on UI in correct
			// order (see #112)
			for (i = children.length - 1; i >= 0; i--) {
				this._moveRows(children[i], node);
			}
		};

		// Special _moveRows case, move children to itself to force sorting
		Tree.prototype._sortChildRows = function(parentNode) {
			return this._moveRows(parentNode, parentNode);
		};

		return Tree;
	})();

	// jQuery Plugin
	methods = {
		init: function(options, force) {
			var settings;

			settings = $.extend({
				branchAttr: "ttBranch",
				clickableNodeNames: false,
				column: 0,
				columnElType: "td", // i.e. 'td', 'th' or 'td,th'
				expandable: false,
				expanderTemplate: "<a href='#'>&nbsp;</a>",
				indent: 19,
				indenterTemplate: "<span class='indenter'></span>",
				initialState: "collapsed",
				nodeIdAttr: "ttId", // maps to data-tt-id
				parentIdAttr: "ttParentId", // maps to data-tt-parent-id
				stringExpand: "展开",
				stringCollapse: "收起",

				// Events
				onInitialized: null,
				onNodeCollapse: null,
				onNodeExpand: null,
				onNodeInitialized: null
			}, options);

			return this.each(function() {
				var el = $(this), tree;

				if (force || el.data("treetable") === undefined) {
					tree = new Tree(this, settings);
					tree.loadRows(this.rows).render();

					el.addClass("treetable").data("treetable", tree);

					if (settings.onInitialized != null) {
						settings.onInitialized.apply(tree);
					}
				}

				return el;
			});
		},

		destroy: function() {
			return this.each(function() {
				return $(this).removeData("treetable").removeClass("treetable");
			});
		},

		collapseAll: function() {
			this.data("treetable").collapseAll();
			return this;
		},

		collapseNode: function(id) {
			var node = this.data("treetable").tree[id];

			if (node) {
				node.collapse();
			} else {
				throw new Error("Unknown node '" + id + "'");
			}

			return this;
		},

		expandAll: function() {
			this.data("treetable").expandAll();
			return this;
		},

		expandNode: function(id) {
			var node = this.data("treetable").tree[id];

			if (node) {
				if (!node.initialized) {
					node._initialize();
				}

				node.expand();
			} else {
				throw new Error("Unknown node '" + id + "'");
			}

			return this;
		},

		loadBranch: function(node, rows) {
			var settings = this.data("treetable").settings, tree = this.data("treetable").tree;

			// TODO Switch to $.parseHTML
			rows = $(rows);

			if (node == null) { // Inserting new root nodes
				this.append(rows);
			} else {
				var lastNode = this.data("treetable").findLastNode(node);
				rows.insertAfter(lastNode.row);
			}

			this.data("treetable").loadRows(rows);

			// Make sure nodes are properly initialized
			rows.filter("tr").each(function() {
				tree[$(this).data(settings.nodeIdAttr)].show();
			});

			if (node != null) {
				// Re-render parent to ensure expander icon is shown (#79)
				node.render().expand();
			}

			return this;
		},

		move: function(nodeId, destinationId) {
			var destination, node;

			node = this.data("treetable").tree[nodeId];
			destination = this.data("treetable").tree[destinationId];
			this.data("treetable").move(node, destination);

			return this;
		},

		node: function(id) {
			return this.data("treetable").tree[id];
		},

		removeNode: function(id) {
			var node = this.data("treetable").tree[id];

			if (node) {
				this.data("treetable").removeNode(node);
			} else {
				throw new Error("Unknown node '" + id + "'");
			}

			return this;
		},

		reveal: function(id) {
			var node = this.data("treetable").tree[id];

			if (node) {
				node.reveal();
			} else {
				throw new Error("Unknown node '" + id + "'");
			}

			return this;
		},

		sortBranch: function(node, columnOrFunction) {
			var settings = this.data("treetable").settings, prepValue, sortFun;

			columnOrFunction = columnOrFunction || settings.column;
			sortFun = columnOrFunction;

			if ($.isNumeric(columnOrFunction)) {
				sortFun = function(a, b) {
					var extractValue, valA, valB;

					extractValue = function(node) {
						var val = node.row.find("td:eq(" + columnOrFunction + ")").text();
						// Ignore trailing/leading whitespace and use uppercase values for
						// case insensitive ordering
						return $.trim(val).toUpperCase();
					}

					valA = extractValue(a);
					valB = extractValue(b);

					if (valA < valB)
						return -1;
					if (valA > valB)
						return 1;
					return 0;
				};
			}

			this.data("treetable").sortBranch(node, sortFun);
			return this;
		},

		unloadBranch: function(node) {
			this.data("treetable").unloadBranch(node);
			return this;
		}
	};

	$.fn.treetable = function(method) {
		if (methods[method]) {
			return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
		} else if (typeof method === 'object' || !method) {
			return methods.init.apply(this, arguments);
		} else {
			return $.error("Method " + method + " does not exist on jQuery.treetable");
		}
	};

	// Expose classes to world
	this.TreeTable || (this.TreeTable = {});
	this.TreeTable.Node = Node;
	this.TreeTable.Tree = Tree;
})(jQuery);
